<!DOCTYPE html>
<html lang="zh-cn">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <title>JS深入系列 - ZzmHub Blog</title>
  <meta name="renderer" content="webkit" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"/>

<meta http-equiv="Cache-Control" content="no-transform" />
<meta http-equiv="Cache-Control" content="no-siteapp" />

<meta name="theme-color" content="#f8f5ec" />
<meta name="msapplication-navbutton-color" content="#f8f5ec">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="#f8f5ec">


<meta name="author" content="ZzmHub" /><meta name="description" content="type 和 instanceof typeof 基本类型和引用类型 类型 值 Undefined &amp;ldquo;undefined&amp;rdquo; Null &amp;ldquo;object&amp;rdquo; (历史遗留问题) Boolean &amp;ldquo;boolean&amp;rdquo; Number &amp;ldquo;number&amp;rdquo; String &amp;ldquo;string&amp;rdquo; Object Array &amp;ldquo;object&amp;rdquo; instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。" /><meta name="keywords" content="Hugo, theme, even" />






<meta name="generator" content="Hugo 0.69.2 with theme even" />


<link rel="canonical" href="https://meilanziqing.gitee.io/zhi-blogs/post/js%E5%9F%BA%E7%A1%80/js%E6%B7%B1%E5%85%A5/" />
<link rel="apple-touch-icon" sizes="180x180" href="/zhi-blogs/apple-touch-icon.png">
<link rel="icon" type="image/png" sizes="32x32" href="/zhi-blogs/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="16x16" href="/zhi-blogs/favicon-16x16.png">
<link rel="manifest" href="/zhi-blogs/manifest.json">
<link rel="mask-icon" href="/zhi-blogs/safari-pinned-tab.svg" color="#5bbad5">



<link href="/zhi-blogs/sass/main.min.4eb71590ad024de2ebb1b5eef94cbb645b7e63e6b9c4c837355530a75e112ce1.css" rel="stylesheet">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3.1.20/dist/jquery.fancybox.min.css" integrity="sha256-7TyXnr2YU040zfSP+rEcz29ggW4j56/ujTPwjMzyqFY=" crossorigin="anonymous">


<meta property="og:title" content="JS深入系列" />
<meta property="og:description" content="type 和 instanceof typeof 基本类型和引用类型 类型 值 Undefined &ldquo;undefined&rdquo; Null &ldquo;object&rdquo; (历史遗留问题) Boolean &ldquo;boolean&rdquo; Number &ldquo;number&rdquo; String &ldquo;string&rdquo; Object Array &ldquo;object&rdquo; instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。" />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://meilanziqing.gitee.io/zhi-blogs/post/js%E5%9F%BA%E7%A1%80/js%E6%B7%B1%E5%85%A5/" />
<meta property="article:published_time" content="2020-09-02T22:58:09+08:00" />
<meta property="article:modified_time" content="2020-09-02T22:58:09+08:00" />
<meta itemprop="name" content="JS深入系列">
<meta itemprop="description" content="type 和 instanceof typeof 基本类型和引用类型 类型 值 Undefined &ldquo;undefined&rdquo; Null &ldquo;object&rdquo; (历史遗留问题) Boolean &ldquo;boolean&rdquo; Number &ldquo;number&rdquo; String &ldquo;string&rdquo; Object Array &ldquo;object&rdquo; instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。">
<meta itemprop="datePublished" content="2020-09-02T22:58:09&#43;08:00" />
<meta itemprop="dateModified" content="2020-09-02T22:58:09&#43;08:00" />
<meta itemprop="wordCount" content="2136">



<meta itemprop="keywords" content="js原理层," /><meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content="JS深入系列"/>
<meta name="twitter:description" content="type 和 instanceof typeof 基本类型和引用类型 类型 值 Undefined &ldquo;undefined&rdquo; Null &ldquo;object&rdquo; (历史遗留问题) Boolean &ldquo;boolean&rdquo; Number &ldquo;number&rdquo; String &ldquo;string&rdquo; Object Array &ldquo;object&rdquo; instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。"/>

<!--[if lte IE 9]>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/classlist/1.1.20170427/classList.min.js"></script>
<![endif]-->

<!--[if lt IE 9]>
  <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
<![endif]-->

</head>
<body>
  <div id="mobile-navbar" class="mobile-navbar">
  <div class="mobile-header-logo">
    <a href="/zhi-blogs/" class="logo">ZzmHub</a>
  </div>
  <div class="mobile-navbar-icon">
    <span></span>
    <span></span>
    <span></span>
  </div>
</div>
<nav id="mobile-menu" class="mobile-menu slideout-menu">
  <ul class="mobile-menu-list">
    <a href="/zhi-blogs/">
        <li class="mobile-menu-item">首页</li>
      </a><a href="/zhi-blogs/post/">
        <li class="mobile-menu-item">归档</li>
      </a><a href="/zhi-blogs/categories/">
        <li class="mobile-menu-item">分类</li>
      </a><a href="/zhi-blogs/tags/">
        <li class="mobile-menu-item">标签</li>
      </a><a href="/zhi-blogs/about/">
        <li class="mobile-menu-item">关于</li>
      </a>
  </ul>
</nav>
  <div class="container" id="mobile-panel">
    <header id="header" class="header">
        <div class="logo-wrapper">
  <a href="/zhi-blogs/" class="logo">ZzmHub</a>
</div>

<nav class="site-navbar">
  <ul id="menu" class="menu">
    <li class="menu-item">
        <a class="menu-item-link" href="/zhi-blogs/">首页</a>
      </li><li class="menu-item">
        <a class="menu-item-link" href="/zhi-blogs/post/">归档</a>
      </li><li class="menu-item">
        <a class="menu-item-link" href="/zhi-blogs/categories/">分类</a>
      </li><li class="menu-item">
        <a class="menu-item-link" href="/zhi-blogs/tags/">标签</a>
      </li><li class="menu-item">
        <a class="menu-item-link" href="/zhi-blogs/about/">关于</a>
      </li>
  </ul>
</nav>
    </header>

    <main id="main" class="main">
      <div class="content-wrapper">
        <div id="content" class="content">
          <article class="post">
    
    <header class="post-header">
      <h1 class="post-title">JS深入系列</h1>

      <div class="post-meta">
        <span class="post-time"> 2020-09-02 </span>
        <div class="post-category">
            <a href="/zhi-blogs/categories/js%E5%9F%BA%E7%A1%80/"> Js基础 </a>
            </div>
        
      </div>
    </header>

    <div class="post-toc" id="post-toc">
  <h2 class="post-toc-title">文章目录</h2>
  <div class="post-toc-content always-active">
    <nav id="TableOfContents">
  <ul>
    <li><a href="#type-和-instanceof">type 和 instanceof</a></li>
    <li><a href="#原型">原型</a>
      <ul>
        <li><a href="#构造函数的特点">构造函数的特点</a></li>
        <li><a href="#prototype">prototype</a></li>
        <li><a href="#对象的分类">对象的分类</a></li>
      </ul>
    </li>
    <li><a href="#作用域">作用域</a></li>
    <li><a href="#执行上下文栈">执行上下文栈</a></li>
    <li><a href="#变量声明">变量声明</a></li>
    <li><a href="#作用域链">作用域链</a></li>
    <li><a href="#闭包">闭包</a></li>
    <li><a href="#callapplybind">call，apply，bind</a></li>
    <li><a href="#继承">继承</a></li>
  </ul>
</nav>
  </div>
</div>
    <div class="post-content">
      <h2 id="type-和-instanceof">type 和 instanceof</h2>
<p>typeof <code>基本类型</code>和<code>引用类型</code></p>
<table>
<thead>
<tr>
<th align="left">类型</th>
<th align="left">值</th>
</tr>
</thead>
<tbody>
<tr>
<td align="left">Undefined</td>
<td align="left">&ldquo;undefined&rdquo;</td>
</tr>
<tr>
<td align="left">Null</td>
<td align="left">&ldquo;object&rdquo; (历史遗留问题)</td>
</tr>
<tr>
<td align="left">Boolean</td>
<td align="left">&ldquo;boolean&rdquo;</td>
</tr>
<tr>
<td align="left">Number</td>
<td align="left">&ldquo;number&rdquo;</td>
</tr>
<tr>
<td align="left">String</td>
<td align="left">&ldquo;string&rdquo;</td>
</tr>
<tr>
<td align="left">Object Array</td>
<td align="left">&ldquo;object&rdquo;</td>
</tr>
</tbody>
</table>
<p>instanceof <code>运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。</code></p>
<p>使用两者结合封装函数来判断类型</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span><span class="lnt">12
</span><span class="lnt">13
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function getDataType(obj) {
    if(obj === null){
        return &#34;null&#34;;
    }else if(typeof obj === &#34;object&#34;){
        if(obj instanceof Array){
            return &#34;array&#34;;
        }else{
            return &#34;object&#34;;
        }
    }else{
        return typeof obj;
    }
}
</code></pre></td></tr></table>
</div>
</div><h2 id="原型">原型</h2>
<p>在典型的oop（面向对象编程）的语言中，如java,都存在类的概念，类就是对象的模板，对象就是类的实例。<br>
但在js中不存在类的概念，js不是基于类，而是通过<code>构造函数</code>(constructor)和<code>原型链</code>（prototypechains）实现的。<br>
但在ES6中引入了类（class）这个概念，作为对象的模板，新的class写法知识让原型对象的写法更加清晰。<!-- raw HTML omitted --></p>
<h3 id="构造函数的特点">构造函数的特点</h3>
<ul>
<li>构造函数的首字母必须大写，用来区分于普通函数</li>
<li>内部使用的this对象，来指向即将要生成的实例对象</li>
<li>使用New来生成实例对象</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span><span class="lnt">8
</span><span class="lnt">9
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function Person(name,age){
       this.name = name;    
       this.age = age;   
       this.sayHello = function(){   
           console.log(this.name +&#34;say hello&#34;);
      }
  }
 var boy = new Person(&#34;bella&#34;,23);    
 boy.sayHello(); // bella say hello
</code></pre></td></tr></table>
</div>
</div><p>所有的实例对象都可以继承构造器函数中的属性和方法。但是，同一个构造函数构造出来的对象实例之间，无法共享属性</p>
<p><strong>解决思路：</strong></p>
<ul>
<li>所有实例都会通过原型链引用到prototype</li>
<li>prototype相当于特定类型所有实例都可以访问到的一个公共容器</li>
<li>那么我们就将重复的东西放到公共容易就好了</li>
</ul>
<p><strong>解析</strong></p>
<ul>
<li>构造函数的prototype属性指向实例原型，实例原型的constructor属性指向回构造函数</li>
<li>对象实例的__proto__属性指向实例对象</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span><span class="lnt">12
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function Person(name,age){
      this.name = name;
      this.age = age;
  }
  Person.propotype.sayHello = function(){
      console.log(this.name + &#34;say hello&#34;);
  }
  var girl = new Person(&#34;bella&#34;,23);
  var boy = new Person(&#34;alex&#34;,23);
 console.log(girl.name);  //bella
 console.log(boy.name);   //alex
 console.log(girl.sayHello === boy.sayHello);  //true
</code></pre></td></tr></table>
</div>
</div><h3 id="prototype">prototype</h3>
<p>js中每个数据类型都是对象，除了null 和 undefined,而每个对象都是继承自一个原型对象，只有null除外，它没有自己的原型对象，最终的Object的原型为null</p>
<h3 id="对象的分类">对象的分类</h3>
<p>JS中万物都是对象，但是对象也分为：普通对象和函数对象，也就是<code>Object</code> 和 <code>Function</code><br>
那么怎么区分普通对象和函数对象呢？<br>
凡是通过New Function()创建的对象都是函数对象，其他的都是普通对象.需要注意的是：普通对象没有propotype（prototype即是属性也是对象），但是有__proto__属性。<!-- raw HTML omitted --></p>
<p><img src="https://user-gold-cdn.xitu.io/2020/5/24/17244f88fbc4699c?w=581&amp;h=602&amp;f=png&amp;s=64089" alt="示意图"></p>
<h2 id="作用域">作用域</h2>
<p>js的作用域是静态作用域（词法作用域）&ndash;<code>从在哪里定义开始</code><br>
f1在定义的时候， js解析器会给f1定义一个内部的属性叫scope, 按照f1定义时的词法环境，scope是指向window的，所以当f2调用f1的时候，程序首先会在f1的函数体内寻找变量v， 没找到， 就去window中去寻找v，也没有变量v，所以程序就报错了。<br>
也就是说，f1的作用域是在定义的时候就已经决定了，而不是在调用时决定的。这也就是所谓js的静态作用域</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span><span class="lnt">8
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function g(){
    var v=100
    function f(){
        console.log(v)
    }
    f()
}
g() // 100
</code></pre></td></tr></table>
</div>
</div><h2 id="执行上下文栈">执行上下文栈</h2>
<p>JavaScript 引擎并非一行一行地分析和执行程序，而是一段一段地分析执行。当执行一个函数的时候，就会创建一个执行上下文，并且压入执行上下文栈，当函数执行完毕的时候，就会将函数的执行上下文从栈中弹出。</p>
<h2 id="变量声明">变量声明</h2>
<ul>
<li>函数声明<br>
由名称和对应值（函数对象(function-object)）组成一个变量对象的属性被创建<br>
如果变量对象已经存在相同名称的属性，则完全替换这个属性</li>
<li>变量声明<br>
由名称和对应值（undefined）组成一个变量对象的属性被创建；<br>
如果变量名称跟已经声明的形式参数或函数相同，则变量声明不会干扰已经存在的这类属性</li>
</ul>
<p>案例一:函数中只有var 才会变量声明提前</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function f(){
    console.log(a) // Uncaught ReferenceError: a is not defined,报错下面不会执行
    a=1 
}
f()
console.log(a)
</code></pre></td></tr></table>
</div>
</div><div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function f(){
 console.log(a) //undefined
 var a=1 // 变量声明提升,声明为函数f的局部变量
}
f()
console.log(a) // Uncaught ReferenceError: a is not defined,函数外部访问不到a
</code></pre></td></tr></table>
</div>
</div><p>案例二:函数内变量没有，能执行到变量赋值处，该变量就成为全局变量</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">function f(){
 g=1
}
f()
console.log(g)
</code></pre></td></tr></table>
</div>
</div><h2 id="作用域链">作用域链</h2>
<p>当查找变量的时候，会先从当前上下文的变量对象中查找，如果没有找到，就会从父级(词法层面上的父级)执行上下文的变量对象中查找，一直找到全局上下文的变量对象，也就是全局对象。这样由多个执行上下文的变量对象构成的链表就叫做<code>作用域链</code>。</p>
<h2 id="闭包">闭包</h2>
<p>闭包是指那些能够访问自由变量（函数参数也不是函数的局部变量的变量）的函数。<!-- raw HTML omitted -->  组成：<code>闭包 = 函数 + 函数能够访问的自由变量</code><br>
ECMAScript中，闭包指的是：</p>
<ul>
<li>从理论角度：所有的函数。因为它们都在创建的时候就将上层上下文的数据保存起来了。哪怕是简单的全局变量也是如此，因为函数中访问全局变量就相当于是在访问自由变量，这个时候使用最外层的作用域。</li>
<li>从实践角度：以下函数才算是闭包：<br>
1.<code>即使创建它的上下文已经销毁，它仍然存在（比如，内部函数从父函数中返回）</code><br>
2.<code>在代码中引用了自由变量</code></li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">var scope = &#34;global scope&#34;;
function checkscope(){
    var scope = &#34;local scope&#34;;
    function f(){
        return scope;
    }   
    return f;
}

var foo = checkscope();
foo();
</code></pre></td></tr></table>
</div>
</div><p>当我们了解了具体的执行过程后，我们知道 f 执行上下文维护了一个作用域链：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span></code></pre></td>
<td class="lntd">
<pre class="chroma"><code class="language-fallback" data-lang="fallback">fContext = {
    Scope: [AO, checkscopeContext.AO, globalContext.VO],
}
</code></pre></td></tr></table>
</div>
</div><p>对的，就是因为这个作用域链，f 函数依然可以读取到 checkscopeContext.AO 的值，说明<code>当 f 函数引用了 checkscopeContext.AO 中的值</code>的时候，即使 checkscopeContext 被销毁了，但是JavaScript 依然会让 checkscopeContext.AO 活在内存中，f 函数依然可以通过 f 函数的作用域链找到它，正是因为 JavaScript 做到了这一点，从而实现了闭包这个概念。</p>
<h2 id="callapplybind">call，apply，bind</h2>
<p>参考链接：<br>
<a href="https://zhuanlan.zhihu.com/p/50719681">能否模拟实现JS的new操作符</a></p>
<h2 id="继承">继承</h2>

    </div>

    <div class="post-copyright">
  <p class="copyright-item">
    <span class="item-title">文章作者</span>
    <span class="item-content">ZzmHub</span>
  </p>
  <p class="copyright-item">
    <span class="item-title">上次更新</span>
    <span class="item-content">
        2020-09-02
        
    </span>
  </p>
  
  
</div>
<footer class="post-footer">
      <div class="post-tags">
          <a href="/zhi-blogs/tags/js%E5%8E%9F%E7%90%86%E5%B1%82/">js原理层</a>
          </div>
      <nav class="post-nav">
        <a class="prev" href="/zhi-blogs/post/vue/vue&#43;vant/">
            <i class="iconfont icon-left"></i>
            <span class="prev-text nav-default">Vue&#43;vant</span>
            <span class="prev-text nav-mobile">上一篇</span>
          </a>
        <a class="next" href="/zhi-blogs/post/js%E5%9F%BA%E7%A1%80/%E8%B4%9D%E5%8F%B6%E6%96%AF%E6%9B%B2%E7%BA%BF%E5%9C%86%E5%BC%A7/">
            <span class="next-text nav-default">贝叶斯曲线圆弧</span>
            <span class="next-text nav-mobile">下一篇</span>
            <i class="iconfont icon-right"></i>
          </a>
      </nav>
    </footer>
  </article>
        </div>
        

  

  

      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="social-links">
      <a href="mailto:gdmec.zhi@email.com" class="iconfont icon-email" title="email"></a>
      <a href="https://github.com/zhimianhub" class="iconfont icon-github" title="github"></a>
  <a href="https://meilanziqing.gitee.io/zhi-blogs/index.xml" type="application/rss+xml" class="iconfont icon-rss" title="rss"></a>
</div>

<div class="copyright">
  <span class="power-by">
    由 <a class="hexo-link" href="https://gohugo.io">Hugo</a> 强力驱动
  </span>
  <span class="division">|</span>
  <span class="theme-info">
    主题 - 
    <a class="theme-link" href="https://github.com/olOwOlo/hugo-theme-even">Even</a>
  </span>

  

  <span class="copyright-year">
    &copy; 
    2017 - 
    2020
    <span class="heart">
      <i class="iconfont icon-heart"></i>
    </span>
    <span class="author">ZzmHub</span>
  </span>
</div>
    </footer>

    <div class="back-to-top" id="back-to-top">
      <i class="iconfont icon-up"></i>
    </div>
  </div>
  
  <script src="https://cdn.jsdelivr.net/npm/jquery@3.2.1/dist/jquery.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/slideout@1.0.1/dist/slideout.min.js" integrity="sha256-t+zJ/g8/KXIJMjSVQdnibt4dlaDxc9zXr/9oNPeWqdg=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3.1.20/dist/jquery.fancybox.min.js" integrity="sha256-XVLffZaxoWfGUEbdzuLi7pwaUJv1cecsQJQqGLe7axY=" crossorigin="anonymous"></script>



<script type="text/javascript" src="/zhi-blogs/js/main.min.d7b7ada643c9c1a983026e177f141f7363b4640d619caf01d8831a6718cd44ea.js"></script>








</body>
</html>
